home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 7 / Apprentice-Release7.iso / Source Code / Libraries / 3DGPL 1.0 / CODE / TRANS / TRANS-FL.C next >
Encoding:
C/C++ Source or Header  |  1997-03-08  |  9.6 KB  |  266 lines  |  [TEXT/MACA]
  1. /** 3DGPL *************************************************\
  2.  *  ()                                                    *
  3.  *  3-D transformations of coordinates using floats.      *
  4.  *                                                        *
  5.  *  Defines:                                              *
  6.  *   T_init_math             Creating sin/cos tables;     *
  7.  *                                                        *
  8.  *   T_translation           Shifting of coordinates;     *
  9.  *   T_scaling               Scaling coordinates;         *
  10.  *                                                        *
  11.  *   T_set_world_rotation    Viewer's rotation;           *
  12.  *   T_world_rotation        Transforming coordinates;    *
  13.  *   T_set_self_rotation     Object rotation;             *
  14.  *   T_self_rotation         Transforming coordinates;    *
  15.  *                                                        *
  16.  *   T_perspective           Transform to perspective.    *
  17.  *                                                        *
  18.  *  (6/1995) By Sergei Savchenko. (savs@cs.mcgill.ca).    *
  19.  *  Copyright (c) 1995 Sergei Savchenko.                  *
  20.  *  THIS SOURCE CODE CAN'T BE USED FOR COMERCIAL PURPOSES *
  21.  *  WITHOUT AUTHORISATION                                 *
  22. \**********************************************************/
  23.  
  24. #include <math.h>                           /* sin & cos */
  25.  
  26. #ifdef __MWERKS__
  27. #include "hardware.h"           /* fast copy routines */
  28. #include "trans.h"                 /* 3D mathematics */
  29. #else
  30. #include "../hardware/hardware.h"           /* fast copy routines */
  31. #include "../trans/trans.h"                 /* 3D mathematics */
  32. #endif
  33.  
  34. #define T_RADS                  40.7436642  /* pseudo-grads into rads */
  35.  
  36. float T_wx1,T_wx2,T_wx3,T_wy1,T_wy2,T_wy3,T_wz1,T_wz2,T_wz3;
  37. float T_sx1,T_sx2,T_sx3,T_sy1,T_sy2,T_sy3,T_sz1,T_sz2,T_sz3;
  38. float T_sin[256],T_cos[256];                /* precalculated */
  39.  
  40. /**********************************************************\
  41.  *  Initializing tables.                                  *
  42. \**********************************************************/
  43.  
  44. void T_init_math(void)
  45. {
  46.  int i;
  47.  
  48.  for(i=0;i<256;i++)
  49.  {
  50.   T_sin[i]=sin(i/T_RADS);
  51.   T_cos[i]=cos(i/T_RADS);
  52.  }
  53. } 
  54.  
  55. /**********************************************************\
  56.  *  Translation of coordinates.                           *
  57. \**********************************************************/
  58.  
  59. void T_translation(register int *from,register int *to,int length,
  60.            int addx,int addy,int addz
  61.           )
  62. {
  63.  register int i;
  64.  
  65.  for(i=0;i<length;i++)
  66.  {
  67.   (*to++)=(*from++)+addx;
  68.   (*to++)=(*from++)+addy;
  69.   (*to++)=(*from++)+addz;                   /* translation */
  70.  }
  71. }
  72.  
  73. /**********************************************************\
  74.  *  Scaling coordinates. (takes in float parameters).     *
  75. \**********************************************************/
  76.  
  77. void T_scaling(register int *from,register int *to,int length,
  78.            int mulx,int muly,int mulz
  79.           )
  80. {
  81.  register int i;
  82.  
  83.  for(i=0;i<length;i++)
  84.  {
  85.   (*to++)=(int)(*from++)*mulx;
  86.   (*to++)=(int)(*from++)*muly;
  87.   (*to++)=(int)(*from++)*mulz;
  88.  }                                          /* scaling */
  89. }
  90.  
  91. /**********************************************************\
  92.  *  Constructing rotation matrix. (gam-bet-alp), rotation *
  93.  *  then pitch then roll sequence. gam-rotation, bet-pitch*
  94.  *                                 alp-roll.              *
  95.  *                                                        *
  96.  *          Y^    Z           x'=z*sin(gam)+x*cos(gam)    *  
  97.  *           |   /            y'=y                        *
  98.  *           |  / alp         z'=z*cos(gam)-x*sin(gam)    * 
  99.  *          /|<---+                                       *
  100.  *         | |/   |           x"=x'                       *
  101.  *  -------|-+-----------> X  y"=y'*cos(bet)-z'*sin(bet)  *
  102.  *     bet | |   __           z"=y'*sin(bet)+z'*cos(bet)  *
  103.  *         V/|   /| gam                                   *
  104.  *         /----+             x"'=y"*sin(alp)+x"*cos(alp) *
  105.  *        /  |                y"'=y"*cos(alp)-x"*sin(alp) *
  106.  *       /   |                z"'=z"                      *
  107.  *           |                                            *
  108. \**********************************************************/
  109.  
  110. void T_set_world_rotation(int alp,int bet,int gam)
  111. {
  112.  float cosalp,sinalp,cosbet,sinbet,cosgam,singam;
  113.  
  114.  cosalp=T_cos[alp];
  115.  sinalp=T_sin[alp];
  116.  cosbet=T_cos[bet];
  117.  sinbet=T_sin[bet];
  118.  cosgam=T_cos[gam];
  119.  singam=T_sin[gam];                         /* initializing */
  120.  
  121.  T_wx1=singam*sinbet*sinalp + cosgam*cosalp;
  122.  T_wy1=cosbet*sinalp;
  123.  T_wz1=singam*cosalp - cosgam*sinbet*sinalp;
  124.  
  125.  T_wx2=singam*sinbet*cosalp - cosgam*sinalp;
  126.  T_wy2=cosbet*cosalp;
  127.  T_wz2=-cosgam*sinbet*cosalp - singam*sinalp;
  128.  
  129.  T_wx3=-singam*cosbet;
  130.  T_wy3=sinbet;
  131.  T_wz3=cosgam*cosbet;                       /* calculating the matrix */
  132. }
  133.  
  134. /**********************************************************\
  135.  *  Rotating coordinates.                                 *
  136.  *                                        |wx1 wx2 wx3|   *
  137.  *  T'=T[W]  where:  [x' y' z'] = [x y z]*|wy1 wy2 wy3|   *
  138.  *                                        |wz1 wz2 wz3|   *
  139. \**********************************************************/
  140.  
  141. void T_world_rotation(int *from,register int *to,int length)
  142. {
  143.  register int i;
  144.  register int xt,yt,zt;
  145.  
  146.  for(i=0;i<length;i++)
  147.  {
  148.   xt=*from++;
  149.   yt=*from++;
  150.   zt=*from++;
  151.  
  152.   *to++=(int)(T_wx1*xt+T_wy1*yt+T_wz1*zt);
  153.   *to++=(int)(T_wx2*xt+T_wy2*yt+T_wz2*zt);
  154.   *to++=(int)(T_wx3*xt+T_wy3*yt+T_wz3*zt); 
  155.  }
  156. }
  157.  
  158. /**********************************************************\
  159.  *  Constructing rotation matrix. (alp-bet-gam), roll     * 
  160.  *  then pitch then rotation sequence. gam-rotation,      *
  161.  *                                     bet-pitch, alp-roll*
  162.  *                                                        *
  163.  *          Y^    Z           x'=y*sin(alp)+x*cos(alp)    *   
  164.  *           |   /            y'=y*cos(alp)-x*sin(alp)    *
  165.  *           |  / alp         z'=z                        *
  166.  *          /|<---+                                       *
  167.  *         | |/   |           x"=x'                       *
  168.  *  -------|-+-----------> X  y"=y'*cos(bet)-z'*sin(bet)  *
  169.  *     bet | |   __           z"=y'*sin(bet)+z'*cos(bet)  *
  170.  *         V/|   /| gam                                   *
  171.  *         /----+             x"'=z"*sin(gam)+x"*cos(gam) *
  172.  *        /  |                y"'=y"                      *
  173.  *       /   |                z"'=z"*cos(gam)-x"*sin(gam) *
  174.  *           |                                            *
  175. \**********************************************************/
  176.  
  177. void T_set_self_rotation(int alp,int bet,int gam)
  178. {
  179.  float cosalp,sinalp,cosbet,sinbet,cosgam,singam;
  180.  
  181.  cosalp=T_cos[alp];
  182.  sinalp=T_sin[alp];
  183.  cosbet=T_cos[bet];
  184.  sinbet=T_sin[bet];
  185.  cosgam=T_cos[gam];
  186.  singam=T_sin[gam];                         /* initializing */
  187.  
  188.  T_sx1=cosalp*cosgam-sinalp*sinbet*singam;
  189.  T_sy1=sinalp*cosgam+cosalp*sinbet*singam;
  190.  T_sz1=cosbet*singam;
  191.  
  192.  T_sx2=-sinalp*cosbet;
  193.  T_sy2=cosalp*cosbet;
  194.  T_sz2=-sinbet;
  195.  
  196.  T_sx3=-cosalp*singam-sinalp*sinbet*cosgam;
  197.  T_sy3=cosalp*sinbet*cosgam-sinalp*singam;
  198.  T_sz3=cosbet*cosgam;                       /* calculating the matrix */
  199. }
  200.  
  201. /**********************************************************\
  202.  *  Rotating coordinates.                                 *
  203.  *                                        |sx1 sx2 sx3|   *
  204.  *  T'=T[S]  where:  [x' y' z'] = [x y z]*|sy1 sy2 sy3|   *
  205.  *                                        |sz1 sz2 sz3|   *
  206. \**********************************************************/
  207.  
  208. void T_self_rotation(int *from,register int *to,int length)
  209. {
  210.  register int i;
  211.  register int xt,yt,zt;
  212.  
  213.  for(i=0;i<length;i++)
  214.  {
  215.   xt=*from++;
  216.   yt=*from++;
  217.   zt=*from++;
  218.  
  219.   *to++=(int)(T_sx1*xt+T_sy1*yt+T_sz1*zt);
  220.   *to++=(int)(T_sx2*xt+T_sy2*yt+T_sz2*zt);
  221.   *to++=(int)(T_sx3*xt+T_sy3*yt+T_sz3*zt); 
  222.  }
  223. }
  224.  
  225. /**********************************************************\
  226.  *  Transforming to perspective, coordinates passed ase   *
  227.  *                        supposed to be both volume, and *  
  228.  *                *       Z-clipped, otherwise division   *
  229.  *               /|X      by 0 or overflow can occur.     *
  230.  *              / |                                       *
  231.  *             /  |                                       *
  232.  *            *   |                                       *
  233.  *           /|X' |       X'      X                       *
  234.  *          / |   |    ------- = ---                      *
  235.  *         /  |   |     focus     Z                       *
  236.  *        *---+---+                                       *
  237.  *        0   ^   Z    X'= X*focus/Z                      *
  238.  *            |                                           *
  239.  *          focus                                         *
  240.  *                                                        *
  241.  *  ADDITIONAL FUNCTIONS: 1) changing formats:            *
  242.  *  ---------------------                                 *
  243.  *    source:       x, y ,z,a1,...,aN where N==dimension-3*
  244.  *    destanation:  x',y',  a1,...,aN                     *
  245.  *                                                        *
  246.  *  2) performs translation to the screen centre.         *
  247. \**********************************************************/
  248.  
  249. void T_perspective(register int *from,register int *to,
  250.            int dimension,int length
  251.           )
  252. {
  253.  register int i;
  254.  
  255.  dimension-=3;                              /* other then X,Y */
  256.  
  257.  for(i=0;i<length;i++,from+=dimension,to+=dimension) 
  258.  {                                          /* Z is not being changed */
  259.   to[0]=((((long)from[0])<<T_LOG_FOCUS)/from[2])+HW_SCREEN_X_CENTRE;
  260.   to[1]=((((long)from[1])<<T_LOG_FOCUS)/from[2])+HW_SCREEN_Y_CENTRE;
  261.   HW_copy_int(from+=3,to+=2,dimension);
  262.  }
  263. }
  264.  
  265. /**********************************************************/
  266.